Chained AssertJ assertions should be simplified to the corresponding dedicated assertion

intentionality - clear

maintainability

Code Smell

MinorSonarSource default severity
click to learn more

Quick FixIDE quick fixes available with SonarLint

Why is this an issue?

AssertJ contains many assertions methods specific to common types. Both versions will test the same things, but the dedicated one will provide a better error message, simplifying the debugging process.

This rule reports an issue when an assertion can be simplified to a dedicated one.

The array below gives a non-exhaustive list of assertion reported by the rule. Code behaving similarly, or with a negation will also be reported.

Original	Dedicated
Related to Object
`assertThat(getObject()).isEqualTo(null)`	`assertThat(getObject()).isNull()`
`assertThat(getBoolean()).isEqualTo(true)`	`assertThat(getBoolean()).isTrue()`
`assertThat(getBoolean()).isEqualTo(false)`	`assertThat(getBoolean()).isFalse()`
`assertThat(x.equals(y)).isTrue()`	`assertThat(x).isEqualTo(y)`
`assertThat(x == y).isTrue()`	`assertThat(x).isSameAs(y)`
`assertThat(x == null).isTrue()`	`assertThat(x).isNull()`
`assertThat(x.toString()).isEqualTo(y)`	`assertThat(x).hasToString(y)`
`assertThat(x.hashCode()).isEqualTo(y.hashCode())`	`assertThat(x).hasSameHashCodeAs(y)`
`assertThat(getObject() instanceof MyClass).isTrue()`	`assertThat(getObject()).isInstanceOf(MyClass.class)`
Related to `Comparable`
`assertThat(x.compareTo(y)).isZero()`	`assertThat(x).isEqualByComparingTo(y)`
`assertThat(x >= y).isTrue()`	`assertThat(x).isGreaterThanOrEqualTo(y)`
`assertThat(x > y).isTrue()`	`assertThat(x).isGreaterThan(y)`
`assertThat(x <= y).isTrue()`	`assertThat(x).isLessThanOrEqualTo(y)`
`assertThat(x < y).isTrue()`	`assertThat(x).isLessThan(y)`
Related to `String`
`assertThat(getString().isEmpty()).isTrue()`	`assertThat(getString()).isEmpty()`
`assertThat(getString()).hasSize(0)`	`assertThat(getString()).isEmpty()`
`assertThat(getString().equals(expected)).isTrue()`	`assertThat(getString()).isEqualTo(expected)`
`assertThat(getString().equalsIgnoreCase(expected)).isTrue()`	`assertThat(getString()).isEqualToIgnoringCase(expected)`
`assertThat(getString().contains(expected)).isTrue()`	`assertThat(getString()).contains(expected)`
`assertThat(getString().startsWith(expected)).isTrue()`	`assertThat(getString()).startsWith(expected)`
`assertThat(getString().endsWith(expected)).isTrue()`	`assertThat(getString()).endsWith(expected)`
`assertThat(getString().matches(expected)).isTrue()`	`assertThat(getString()).matches(expected)`
`assertThat(getString().trim()).isEmpty()`	`assertThat(getString()).isBlank()`
`assertThat(getString().length()).isEqualTo(length)`	`assertThat(getString()).hasSize(length)`
`assertThat(getString().length()).hasSize(expected.length())`	`assertThat(getString()).hasSameSizeAs(expected)`
Related to `File`
`assertThat(getFile()).hasSize(0)`	`assertThat(getFile()).isEmpty()`
`assertThat(getFile().length()).isZero()`	`assertThat(getFile()).isEmpty()`
`assertThat(getFile().length()).isEqualTo(length)`	`assertThat(getFile()).hasSize(length)`
`assertThat(getFile().canRead()).isTrue()`	`assertThat(getFile()).canRead()`
`assertThat(getFile().canWrite()).isTrue()`	`assertThat(getFile()).canWrite()`
`assertThat(getFile().exists()).isTrue()`	`assertThat(getFile()).exists()`
`assertThat(getFile().getName()).isEqualTo(name)`	`assertThat(getFile()).hasName(name)`
`assertThat(getFile().getParent()).isEqualTo(pathname)`	`assertThat(getFile()).hasParent(pathname)`
`assertThat(getFile().getParentFile()).isNull()`	`assertThat(getFile()).hasNoParent()`
`assertThat(getFile().isAbsolute()).isTrue()`	`assertThat(getFile()).isAbsolute()`
`assertThat(getFile().isAbsolute()).isFalse()`	`assertThat(getFile()).isRelative()`
`assertThat(getFile().isDirectory()).isTrue()`	`assertThat(getFile()).isDirectory()`
`assertThat(getFile().isFile()).isTrue()`	`assertThat(getFile()).isFile()`
`assertThat(getFile().list()).isEmpty()`	`assertThat(getFile()).isEmptyDirectory()`
Related to `Path`
`assertThat(getPath().startsWith(path)).isTrue()`	`assertThat(getPath()).startsWithRaw(path)`
`assertThat(getPath().endsWith(path)).isTrue()`	`assertThat(getPath()).endsWithRaw(path)`
`assertThat(getPath().getParent()).isEqualTo(name)`	`assertThat(getPath()).hasParentRaw(name)`
`assertThat(getPath().getParent()).isNull()`	`assertThat(getPath()).hasNoParentRaw()`
`assertThat(getPath().isAbsolute()).isTrue()`	`assertThat(getPath()).isAbsolute()`
`assertThat(getPath().isAbsolute()).isFalse()`	`assertThat(getPath()).isRelative()`
Related to `Array`
`assertThat(getArray().length).isZero()`	`assertThat(getArray()).isEmpty()`
`assertThat(getArray().length).isEqualTo(length)`	`assertThat(getArray()).hasSize(length)`
`assertThat(getArray().length).isEqualTo(anotherArray.length)`	`assertThat(getArray()).hasSameSizeAs(anotherArray)`
`assertThat(getArray().length).isLessThanOrEqualTo(expression)`	`assertThat(getArray()).hasSizeLessThanOrEqualTo(expression)`
`assertThat(getArray().length).isLessThan(expression)`	`assertThat(getArray()).hasSizeLessThan(expression)`
`assertThat(getArray().length).isGreaterThan(expression)`	`assertThat(getArray()).hasSizeGreaterThan(expression)`
`assertThat(getArray().length).isGreaterThanOrEqualTo(expression)`	`assertThat(getArray()).hasSizeGreaterThanOrEqualTo(expression)`
Related to `Collection`
`assertThat(getCollection().isEmpty()).isTrue()`	`assertThat(getCollection()).isEmpty()`
`assertThat(getCollection().size()).isZero()`	`assertThat(getCollection()).isEmpty()`
`assertThat(getCollection().contains(something)).isTrue()`	`assertThat(getCollection()).contains(something)`
`assertThat(getCollection().containsAll(otherCollection)).isTrue()`	`assertThat(getCollection()).containsAll(otherCollection)`
Related to `Map`
`assertThat(getMap().size()).isEqualTo(otherMap().size()`	`assertThat(getMap()).hasSameSizeAs(otherMap())`
`assertThat(getMap().containsKey(key)).isTrue()`	`assertThat(getMap()).containsKey(key)`
`assertThat(getMap().keySet()).contains(key)`	`assertThat(getMap()).containsKey(key)`
`assertThat(getMap().keySet()).containsOnlyKey(key)`	`assertThat(getMap()).containsOnlyKey(key)`
`assertThat(getMap().containsValue(value)).isTrue()`	`assertThat(getMap()).containsValue(value)`
`assertThat(getMap().values()).contains(value)`	`assertThat(getMap()).containsValue(value)`
`assertThat(getMap().get(key)).isEqualTo(value)`	`assertThat(getMap()).containsEntry(key, value)`
Related to `Optional`
`assertThat(getOptional().isPresent()).isTrue()`	`assertThat(getOptional()).isPresent()`
`assertThat(getOptional().get()).isEqualTo(something)`	`assertThat(getOptional()).contains(something)`
`assertThat(getOptional().get()).isSameAs(something)`	`assertThat(getOptional()).containsSame(something)`

Noncompliant code example

assertThat(getObject()).isEqualTo(null); // Noncompliant
assertThat(getObject()).isNotEqualTo(null); // Noncompliant - not listed above but also supported

assertThat(getString().trim()).isEmpty();
assertThat(getFile().canRead()).isTrue();
assertThat(getPath().getParent()).isNull();

Compliant solution

assertThat(getObject()).isNull();
assertThat(getObject()).isNotNull();

assertThat(getString()).isBlank();
assertThat(getFile()).canRead();
assertThat(getPath()).hasNoParentRaw();

Available In:

Catch issues on the fly,
in your IDE

Detect issues in your GitHub, Azure DevOps Services, Bitbucket Cloud, GitLab repositories

Analyze code in your
on-premise CI

In-IDE

SaaS

Self-Hosted